package com.jeeplus.test.jlnu.admissionInfo.utils;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jeeplus.test.jlnu.archivalBatch.util.DateUtils;
import com.jeeplus.test.jlnu.xlsxManage.domain.entity.JlnuXlsxManage;
import com.jeeplus.test.jlnu.xlsxManage.service.JlnuXlsxManageService;
import org.springframework.util.StringUtils;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author wj
 * @createDate 2025/09/01
 */
public class VerifyExcel {

    /**
     * 查询模板库内容并转换为Map列表
     *
     * @param jlnuXlsxManageService 模板服务
     * @param templateInfoType      模板类型
     * @param officeId              机构ID
     * @return 模板内容Map列表，如果查询失败返回空列表
     */
    public static List<Map<String, Object>> getTemplateContent(JlnuXlsxManageService jlnuXlsxManageService,
                                                               int templateId) {
        List<Map<String, Object>> content = new ArrayList<>();

        try {
            // 查模板库对应数据（入参加id）
            //JlnuXlsxManage jlnuXlsxManage = jlnuXlsxManageService.queryByType(templateInfoType, officeId);
            JlnuXlsxManage jlnuXlsxManage = jlnuXlsxManageService.queryById(templateId);

            if (jlnuXlsxManage != null && jlnuXlsxManage.getContent() != null) {
                ObjectMapper objectMapper = new ObjectMapper();
                content = objectMapper.readValue(
                        jlnuXlsxManage.getContent(),
                        new TypeReference<List<Map<String, Object>>>() {
                        }
                );
            }
        } catch (Exception exp) {
            // 记录日志而不是直接打印堆栈
            System.err.println("获取模板内容失败: " + exp.getMessage());
            // 或者使用日志框架：logger.error("获取模板内容失败", exp);
        }

        return content != null ? content : new ArrayList<>();
    }


    /**
     * 验证对象字段是否符合内容映射规则
     *
     * @param object       要验证的对象
     * @param finalContent 内容映射规则列表
     * @param errorList    错误信息列表
     */

    //获取content动态json和导入模板字段
//    public static void validateObjectFields(Object object, List<Map<String, Object>> finalContent, List<String> errorList) {
//        try {
//            for (Map<String, Object> contentMap : finalContent) {
//                // 获取对象的 Class 对象
//                Class<?> clazz = object.getClass();
//                // 获取所有声明的字段（包括 private）
//                Field[] fields = clazz.getDeclaredFields();
//
//                for (Field field : fields) {
//                    // 数据dataList中匹配对应模板库规则
//                    if (field.getName().equals(contentMap.get("label").toString())) {
//                        String checkData = null;
//                        field.setAccessible(true);
//
//                        try {
//                            if (field.get(object) != null) {
//                                checkData = checkData(contentMap, field.get(object));
//                            }
//                        } catch (IllegalAccessException ex) {
//                            throw new RuntimeException("抛出异常停止循环：" + ex);
//                        }
//
//                        // 规则验证（类型，最小最大长度）
//                        if (checkData != null) {
//                            // 不通过则向errorList添加错误信息，并return
//                            errorList.add(checkData);
//                            throw new RuntimeException("抛出异常停止循环");
//                        }
//                    }
//                }
//            }
//        } catch (RuntimeException ex) {
//            // 捕获异常并停止处理
//            return;
//        }
//    }

    public static void validateObjectFields(Object object, List<Map<String, Object>> finalContent, List<String> errorList, AtomicInteger index) {
        try {
            for (Map<String, Object> contentMap : finalContent) {
                if(true!=(Boolean) (contentMap.get("state"))){
                    continue;
                }
                // 获取对象的 Class 对象
                Class<?> clazz = object.getClass();
                // 获取所有声明的字段（包括 private）
                Field[] fields = clazz.getDeclaredFields();

                for (Field field : fields) {
                    // 数据dataList中匹配对应模板库规则,不区分大小写
                    if (field.getName().equalsIgnoreCase(contentMap.get("label").toString())) {
                        // 判断是否需要校验 verification = 1无需校验，2非空校验，3自定义正则表达式
                        String verification = contentMap.get("verification")+"";
                        String verificationInformation = contentMap.get("verificationInformation")+"";
                        String checkData = null;
                        field.setAccessible(true);

                        try {
                            Object fieldValue = field.get(object);

                            // 1: 无需校验
                            if ("1".equals(verification)) {
                                continue;
                            }

                            // 2: 非空校验
                            if ("2".equals(verification)) {
                                if (fieldValue == null ||
                                        (fieldValue instanceof String && ((String) fieldValue).trim().isEmpty())) {
                                    checkData = contentMap.get("label") + " 字段不能为空";
                                }
                            }

                            // 3: 自定义正则表达式校验
                           if ("3".equals(verification)) {
                                if (fieldValue != null && fieldValue instanceof String) {
                                    String value = (String) fieldValue;
                                    if (!value.trim().isEmpty()) {
                                        String regex = verificationInformation;
                                        if (!value.matches(regex)) {
                                            checkData = contentMap.get("label") + " 字段格式不正确：" + value;
                                        }
                                    }
                                }
                           }


                        } catch (Exception ex) {
                            checkData = contentMap.get("label") + " 字段校验时发生异常：" + ex.getMessage();
                        }

                        // 规则验证
                        if (!StringUtils.isEmpty(checkData)) {
                            // 不通过则向errorList添加错误信息
                            errorList.add("第"+index+"行 "+checkData);
                            // 如果需要遇到第一个错误就停止，可以取消下面的注释
                            // throw new RuntimeException("抛出异常停止循环");
                        }
                    }
                }
            }
        } catch (RuntimeException ex) {
            // 捕获异常并停止处理
            errorList.add("校验过程中发生异常：" + ex.getMessage());
        }
    }


    //字段验证方法
    public static String checkData(Map<String, Object> contentMap, Object data) {
        Integer minLeng = Integer.parseInt(contentMap.get("minLeng").toString());
        //数据类型验证
        switch (contentMap.get("valueType").toString()) {
            case "string":
                String valueTypeString;
                try {
                    valueTypeString = (String) data;
                } catch (Exception e) {
                    return "string转换异常";
                }
                if (valueTypeString.length() < minLeng) {
                    return "string长度不足";
                }

                break;
            case "int":
                Integer valueTypeInteger;
                try {
                    valueTypeInteger = (Integer) data;
                } catch (Exception e) {
                    return "int转换异常";
                }
                if (valueTypeInteger < (minLeng * 10) - 1) {
                    return "int长度不足";
                }
                break;
            case "number":
                Integer valueTypeNumber;
                try {
                    valueTypeNumber = Integer.parseInt(data.toString());
                } catch (Exception e) {
                    return "number转换异常";
                }
                if (valueTypeNumber < (minLeng * 10) - 1) {
                    return "number长度不足";
                }
                break;
            case "date":
                int valueTypeDate = 0;
                try {
                    DateUtils.parseDate(data.toString(), DateUtils.getCurrentDates());
                    valueTypeDate = valueTypeDate++;
                } catch (Exception e) {
                    //搁置
                }
                try {
                    DateUtils.parseDate(data.toString(), DateUtils.getCurrentDateTime());
                    valueTypeDate = valueTypeDate++;
                } catch (Exception e) {
                    //搁置
                }
                if (valueTypeDate == 0) {
                    return "date转换异常";
                }
                if (data.toString().length() < minLeng) {
                    return "date长度不足";
                }
                break;
            case "dateTime":
                int valueTypeDateTime = 0;
                try {
                    DateUtils.parseDate(data.toString(), DateUtils.getCurrentDates());
                    valueTypeDateTime = valueTypeDateTime++;
                } catch (Exception e) {
                    //搁置
                }
                try {
                    DateUtils.parseDate(data.toString(), DateUtils.getCurrentDateTime());
                    valueTypeDateTime = valueTypeDateTime++;
                } catch (Exception e) {
                    //搁置
                }
                if (valueTypeDateTime == 0) {
                    return "date转换异常";
                }
                if (data.toString().length() < minLeng) {
                    return "date长度不足";
                }
                break;
        }
        return null;
    }

}
